C++ version of the GNU getopt function

The GetOpt class provides an efficient and structured mechanism for processing command-line options from an application program.  The sample program fragment below illustrates a typical use of the GetOpt class for some hypothetical application program:

#include <stdio.h>
#include <GetOpt.h>
//...
int debug_flag, compile_flag, size_in_bytes;

int
main (int argc, char **argv)
{
  // Invokes ctor `GetOpt (int argc, char **argv, 
  //                       char *optstring);'
  GetOpt getopt (argc, argv, "dcs:");
  int option_char;
  
  // Invokes member function `int operator ()(void);'
  while ((option_char = getopt ()) != EOF)
    switch (option_char)
      {  
         case 'd': debug_flag = 1; break;
         case 'c': compile_flag = 1; break;
         case 's': size_in_bytes = atoi (getopt.optarg); break;
         case '?': fprintf (stderr, 
                            "usage: %s [dcs<size>]\n", argv[0]);
      }
}

Unlike the C library version, the libg++ GetOpt class uses its constructor to initialize class data members containing the argument count, argument vector, and the option string.  This simplifies the interface for each subsequent call to member function int operator ()(void).

The C version, on the other hand, uses hidden static variables to retain the option string and argument list values between calls to getopt.  This complicates the getopt interface since the argument count, argument vector, and option string must be passed as parameters for each invocation.  For the C version, the loop in the previous example becomes:

  while ((option_char = getopt (argc, argv, "dcs:")) != EOF)
    // ...

which requires extra overhead to pass the parameters for every call.

Along with the GetOpt constructor and int operator ()(void), the other relevant elements of class GetOpt are:

char *optarg	Used for communication from operator ()(void) to the caller. When operator ()(void) finds an option that takes an argument, the argument value is stored here.

int optind	Index in argv of the next element to be scanned. This is used for communication to and from the caller and for communication between successive calls to operator ()(void).
          
	When operator ()(void) returns EOF, this is the index of the first of the non-option elements that the caller should itself scan.
              
	Otherwise, optind communicates from one call to the next how much of argv has been scanned so far.

The libg++ version of GetOpt acts like standard UNIX getopt for the calling routine, but it behaves differently for the user, since it allows the user to intersperse the options with the other arguments.
      
As GetOpt works, it permutes the elements of argv so that, when it is done, all the options precede everything else.  Thus all application programs are extended to handle flexible argument order.

Setting the environment variable _POSIX_OPTION_ORDER disables permutation.  Then the behavior is completely standard.